"""#使用[]方式来定义列表
name_list=["aang","kang","hgj"]#定义列表
print(name_list)
print(type(name_list))
name_list=["wang",8689,True]
print(name_list)
print(type(name_list))
#定义一个嵌套的列表
name_list=[[1,2,4],[5,52,2]]
print(name_list)
print(type(name_list))
#通过下标索引取出对应位置的元素
name_list=["aang","kang","hgj"]
print(name_list[1])
print(name_list[0])
print(name_list[2])
#print(name_list[3])#错误示范，下标索引超出范围
#通过下标索引取出数据（倒序取出
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])

#去除嵌套列表的元素
name_list=[[1,2,4],[5,52,2]]
print(name_list[1][2])
#演示数据容器之list列表的常用操作
name_list=["aang","kang",562758]
#1.1查找某元素在列表内的下标索引
index=name_list.index("kang")
print(f"下标索引为{index}")
#1.2如果被查找的元素不存在，会报错
#index=name_list.index("gsg")
#print(f"下标索引为{index}")
#2.修改特定下标索引的值
name_list[0]="wang"
print(name_list[0])
name_list[-1]="long"
print(name_list[-1])
print(name_list)
#3.在指定下标位置插入新元素
name_list.insert(4,"niu")
print(f"插入完后的列表为{name_list}")
#4.在列表尾部追加""单个""新元素
name_list.append("bi")
print(name_list)
#5.在列表尾部追击'''一批新元素'''
name_list2=[1,2,3,4]
name_list.extend(name_list2)
print(name_list)
#6.删除指定下标指引的元素

#6.1方式一：del列表[]
del name_list[2]
print(f"删除之后的元素结果是{name_list}")
#6.2方式二：列表.pop（下标）
name=name_list.pop(3)
print(f"通过pop方法取出元素后列表的内容：{name_list}，取出的元素是{name}")
#7.删除某元素在列表片中的第一个匹配项
name_list.remove(3)
print(f"通过remove来删除元素后的结果是{name_list}")
#8.清空列表
name_list.clear()
print(name_list)
#9统计列表内某元素的数量
count=name_list2.count(1)
print(f"统计元素之后的输出结果是{count}")
#10.统计列表内全部元素的数量
lent=len(name_list2)
print(f"统计的元素总数是{lent}")
#列表功能练习
student_year=[21,25,21,23,22,20]
student_year.append(31)
print(f"追加一个数字31到列表的尾部：输出的结果是{student_year}")
new=[29,33,30]
student_year.extend(new)
print(f"追加一个新列表{new},到列表的尾部的输出结果是{student_year}")

print(f"取出第一个元素是{student_year[0]}")
print(f"取出最后一个元素{student_year[-1]}")
look=student_year.index(31)
print(f"查找元素31在列表中的位置shi{look}")
#用while循环遍历列表演示函数
def list_while_func():

    name_list=["长春","理工","大学"]

#循环控制变量通过下标索引来控制，默认0
#每一次循环将下标索引变量加一
#循环条件：下标索引变量<列表的元素数量
#定义一个变量来标记列表的下标
    index=0#初始值为零
    while index<len(name_list):
#通过index变量取出对应下标的元素
        element=name_list[index]
        print(f"列表的元素：{element}")
        index+=1
#使用for循环来遍历列表
def list_for_func():
    name=[5,234,5,6,7,78,]
    for x in name:
        print(f"列表的元素有{x}")

list_for_func()
list_while_func()
#练习，取出列表内的偶数

nums=[1,2,3,4,5,6,7,8,9,10]
s=[]
index=0
while index<len(nums):
    if nums[index]%2==0:
        s.append(nums[index])

    index +=1
print(f"通过while循环，从列表{nums}中取出偶数，组成新列表：{s}")
nums=[1,2,3,4,5,6,7,8,9,10]
s=[]
for x in nums:
    if x%2==0:
        s.append(x)
print(f"通过for循环，从列表{nums}中取出偶数，组成新列表：{s}")
 #定义元组
(1,2,3,4,4,"hello",True)
num=(6,7,8,9,0)
t1=()
print(f"t1的类型是:{type(t1)}")
#定义一个元素的元组
t2=("wang",)
t3=("wang")
print(f"t2的类型是:{type(t2)}")
print(f"t3的类型是:{type(t3)}")
 #元组的嵌套
t4=((1,2,3,),(4,5,6,))
print(f"t4的类型是:{type(t4)}")
#下标索引去取出内容
num=t4[1][2]
print(f"从嵌套元组中取出的数据是：{num}")
#元组的操作：index查找方法
t5=("长春","理工","大学","理工")
index=t5.index("理工")
print(f"在元组中查找到的元素是{index}")

#元组的操作：count统计方法
count=t5.count("理工")
print(f"统计的理工字符串有{count}个")
#元组的操作：len函数统计元组元素数量
qwe=len(t5)
print(f"总共有多少个元素{qwe}")
#元组的遍历：while
num=0
while num<len(t5):
    print(f"元组总共有{num}元素")
    num+=1
#元组的遍历：for
for element in t5:
    print(f"都有{element}元素")
#练习
num=('周杰伦',11,['football','music'])
q=num.index(11)
print(f"年龄所在的下标位置是{q}")
name=num[0]
print(f"学生的姓名是{name}")
hobbies=num[2]
hobbies.remove('football')
print(num)
hobbies.append('coding')
print(num)
#通过下标索引取值
name="wangkanglong123"
value=name[3]
value2=name[-1]
print(value,value2)
#index使用方法
value=name.index("kang")
print(value)
#replace方法
x=name.replace("kang","rencai")
print(x)

#split方法
name=("hgalgh,aghwu,aghh,gahuu")
s=name.split("n")
print(s)

#strip方法
t=name.strip()#不传入参数，默认为空格
print(t)
d=name.strip("3")
print(d)
#统计字符串中某字符串出现的次数
count=name.count("ng")
print(count)
#统计字符串的长度
num=len(name)
print(num)
#while循环遍历字符串
i=0
while i<len(name):
    print(name[i])
    i+=1

#练习
name="itheima itcast boxuegu"
s=name.count("it")
t=name.replace(" ","|")
y=name.split("|")
print(f"字符串itheima itcast boxuegu中有：{s}个it字符")
print(f"字符串itheima itcast boxuegu，被替换空格后，结果：{t}")
print(f"字符串itheima itcast boxuegu，按照|分割后，得到：{y}")
#序列
#对list进行切片
num=[0,1,2,3,45,5,6,7,8,9]
x=num[1:4]
print(x)
#对tuple切片，从头开始，到最后结束，步长为1
num1=(0,1,2,3,45,5,6,7,8,9)
s=num1[:]
print(s)
#对str进行切片，从头开始，到最后结束，步长为2
str1="12345555666"
d=str1[::2]
print(d)
#对str进行切片，从头开始，到最后结束，步长为-1
v=str1[::-1]
print(v)
#对列表进行切片，从3开始，到1结束，步长-1
list1=[1,34,5,6,7,8]
f=list1[3:1:-1]
print(f)
#对元组进行切片，从头开始，到尾结束，步长-2
num1=(0,1,2,3,45,5,6,7,8,9)
b=num1[::-2]
print(b)
#练习
num="万过新月，员序程马黑来，nohtyp学"
#倒序字符串切片取出

s=num[::-1][9:14]

print(s)
#   切片取出，然后倒叙
v=num[5:10][::-1]
print(v)
#spilt分割，replace替换掉来为空，倒序字符串
num="万过新月,员序程马黑来,nohtyp学"
t=num.split(",")[1].replace("来","")[::-1]
print(t)
#集合
#定义集合
set1={"传智教育","黑马程序员","传智教育","黑马程序员","传智教育","黑马程序员","wang","wang","wang"}
set1_empty=set()
print(f"set1的内容是{set1},类型是{type(set1)}")
print(f"set1_empty的内容是{set1_empty},类型是{type(set1_empty)}")
#添加新元素
set1.add("python")
set1.add("黑马程序员")
print(f"set1的内容是{set1},类型是{type(set1)}")
#移除元素
set1.remove("wang")


s=set1.pop()#从集合中随机取出元素
print(s)
#清空集合
set1.clear()

#取两个集合的差集
set1={1,2,3,6,7,8}
set2={4,5,6,7,8,9}
set3=set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
print(f"取出差集后,原有set1的内容是：{set1}")
print(f"取出差集后,原有set2的内容是：{set2}")
#消除两个集合的差集
set1={1,2,3,6,7,8}
set2={4,5,6,7,8,9}
set1.difference_update(set2)

print(f"取出差集后,原有set1的内容是：{set1}")
print(f"取出差集后,原有set2的内容是：{set2}")
#两个集合合并为一个
set1={1,2,3,6,7,8}
set2={4,5,6,7,8,9}
set3=set1.union(set2)
print(f"合并集后的结果是：{set3}")
print(f"合并集后,原有set1的内容是：{set1}")
print(f"合并集后,原有set2的内容是：{set2}")
#统计集合元素数量
num=len(set1)
print(num)
#集合的遍历,不能用while循环，可以用for
for i in set1:
    print(i)
list1=["黑马程序员","传智播客","黑马程序员","传智播客","itheima","itcast","itheima","itcast","best"]
set1=set()
for i in list1:
    set1.add(i)
print(f"有列表：{list1}")
print(f"存入集合后的结果：{set1}
#定义字典字面量
{"wangkanglong":100,"aoligei":99,"qwer":98,"yuio":97}

#定义字典变量
dict1={"wangkanglong":100,"aoligei":99,"qwer":98,"yuio":97}
#定义空字典
dict2={}
dict3=dict()
print(f"字典一的内容是{dict1},字典类型是{type(dict1)}")
print(f"字典一的内容是{dict2},字典类型是{type(dict2)}")
print(f"字典一的内容是{dict3},字典类型是{type(dict3)}")

#定义重复key的字典
dict1={"wangkanglong":100,"aoligei":99,"qwer":98,"qwer":97}
print(f"重复字典的内容是：{dict1}")
#从字典中基于key获取value
score=dict1["wangkanglong"]
print(f"分数是{score}")
#定义嵌套字典
stu_dict={
    "wangkanglong":{
        "wuli":100,
        "yingyu":120,
        "zhengzhi":100
    },
    "zhao":{
        "yuwen":100,
        "dili":99
    },"chen":{
        "poi":100,
         "zhengzhi":78
    }
}
print(f"学生的考试信息是{stu_dict}")
score1=stu_dict["zhao"]["dili"]
print(score1)
#从嵌套字典中获取数据
#新增元素
dict1={"wangkanglong":100,"aoligei":99,"qwer":98,"qwer":97}
dict1["rencai"]=95
print(f"字典更新后的元素{dict1}")
#更新元素
dict1["rencai"]=90
print(f"经过更新后的元素是{dict1}")
#删除元素
score=dict1.pop("rencai")
print(f"被删除的元素的值为{score},字典被移除一个元素后的值为{dict1}")
#清空元素
dict1.clear()
print(f"经过清空后的字典{dict1}")
#获取全部的key
dict1={"wangkanglong":100,"aoligei":99,"qwer":98,"qwer":97}
keys=dict1.keys()
print(f"字典的全部keys是{keys}")
#遍历字典
for key in keys:#方式一：通过获取到全部的key：来完成遍历
    print(f"字典的key是{key}")
    print(f"字典的value是{dict1[key]}")
#方式二：直接对字典进行for循环，每一次循环都是直接得到key
for key in dict1:
    print(f"字典的key是{key}")
    print(f"字典的value是{dict1[key]}")
#统计字典内的元素数量
le=len(dict1)
print(f"字典的数量为{le}")
#升职加薪小作业
dict1={
    "王力宏":{
        "部门":
            "科技部",
        "工资":
            3000,
        "级别":1
    },
       "周杰伦":{
           "部门":"市场部","工资":5000,"级别":2},
       "林俊杰":{"部门":"市场部","工资":7000,"级别":3},
       "张学友":{"部门":"科技部","工资":4000,"级别":1},
       "刘德华":{"部门":"市场部","工资":6000,"级别":2}}
print(f"全体员工当前信息如下{dict1}")
for x in dict1:
    if dict1[x]["级别"]==1:
        dict1[x]["级别"]+=1
        dict1[x]["工资"]+=1000
print(f"全体级别为1的员工完成升职加薪操作后{dict1}")"""
#演示数据容器的通用功能
list1=[1,2,3,4,5,6]
tuple1=(1,2,3,4,5,6)
str1="abcdefg"
set1={1,2,3,4,5,6}
dict1={"key1":1,"key2":2,"key3":3,"key4":4,"key5":5}
#len元素的个数
print(f"列表元素有：{len(list1)}")
print(f"元组元素有：{len(tuple1)}")
print(f"字符串元素有：{len(str1)}")
print(f"集合元素有：{len(set1)}")
print(f"字典元素有：{len(dict1)}")

#max最大的元素
print(f"列表 最大的元素：{max(list1)}")
print(f"元组 最大的元素：{max(tuple1)}")
print(f"字符串最大的元素：{max(str1)}")
print(f"集合 最大的元素：{max(set1)}")
print(f"字典 最大的元素：{max(dict1)}")
#min最小的元素
print(f"列表 最小的元素：{min(list1)}")
print(f"元组 最小的元素：{min(tuple1)}")
print(f"字符串最小的元素：{min(str1)}")
print(f"集合 最小的元素：{min(set1)}")
print(f"字典 最小的元素：{min(dict1)}")
#类型转换：容器转列表
print(f"列表转列表的结果是{list(list1)}")
print(f"元组转列表的结果是{list(tuple1)}")
print(f"字符串转列表的结果是{list(str1)}")
print(f"集合转列表的结果是{list(set1)}")
print(f"字典转列表的结果是{list(dict1)}")
#类型转换：容器转元组
print(f"列表转  元组的结果是{tuple(list1)}")
print(f"元组转  元组的结果是{tuple(tuple1)}")
print(f"字符串转 元组的结果是{tuple(str1)}")
print(f"集合转  元组的结果是{tuple(set1)}")
print(f"字典转  元组的结果是{tuple(dict1)}")
#类型转换：容器转字符串
print(f"列表转  字符串的结果是{str(list1)}")
print(f"元组转  字符串的结果是{str(tuple1)}")
print(f"字符串转 字符串的结果是{str(str1)}")
print(f"集合转  字符串的结果是{str(set1)}")
print(f"字典转  字符串的结果是{str(dict1)}")
#类型转换：容器转集合
print(f"列表转  集合的结果是{set(list1)}")
print(f"元组转  集合的结果是{set(tuple1)}")
print(f"字符串转 集合的结果是{set(str1)}")
print(f"集合转  集合的结果是{set(set1)}")
print(f"字典转  集合的结果是{set(dict1)}")
#sorted排序,容器通用排序，结果会生成列表
print(f"列表元素的排序 结果是{sorted(list1,reverse=True)}")
print(f"元组元素的排序 结果是{sorted(tuple1,reverse=True)}")
print(f"字符串元素的排序结果是{sorted(str1,reverse=True)}")
print(f"集合元素的排序 结果是{sorted(set1,reverse=True)}")
print(f"字典元素的排序 结果是{sorted(dict1,reverse=True)}")